Linux Cubed Series 2: Applications/Linux Cubed Series 2 - Applications.iso/circuits/irsim-ca.2/irsim-ca/irsim-cap-9.2/src/ana11/deltaT.c

C/C++ Source or Header | 1993-01-15 | 5KB | 254 lines

/*
 *     *********************************************************************
 *     * Copyright (C) 1988, 1990 Stanford University.                     *
 *     * Permission to use, copy, modify, and distribute this              *
 *     * software and its documentation for any purpose and without        *
 *     * fee is hereby granted, provided that the above copyright          *
 *     * notice appear in all copies.  Stanford University                 *
 *     * makes no representations about the suitability of this            *
 *     * software for any purpose.  It is provided "as is" without         *
 *     * express or implied warranty.  Export of this software outside     *
 *     * of the United States of America may require an export license.    *
 *     *********************************************************************
 */

#include "ana.h"
#include "ana_glob.h"
#include "graphics.h"


private TimeType FindPreviousEdge( t, tm, edgeH )
  Trptr              t;
  register TimeType  tm;
  hptr               *edgeH;
  {
    register hptr      h;
    register int       val;
    register TimeType  edgeT;

    edgeT = tims.start;
    *edgeH = NULL;
    if( IsVector( t ) )
      {
    register int  i;

    for( i = t->n.vec->nbits - 1; i >= 0; i-- )
      {
        h = t->cache[i].wind;
        val = h->val;
        while( h->time <= tm )
          {
        if( val != h->val )
          {
            val = h->val;
            if( h->time > edgeT )
            edgeT = h->time;
          }
        NEXTH( h, h );
          }
      }
      }
    else
      {
    h = t->cache[0].wind;
    val = h->val;
    while( h->time <= tm )
      {
        if( val != h->val )
          {
        val = h->val;
        edgeT = h->time;
        *edgeH = h;
          }
        NEXTH( h, h );
      }
      }
    return( edgeT );
  }


private TimeType FindNextEdge( t, tm, edgeH )
  Trptr              t;
  register TimeType  tm;
  hptr               *edgeH;
  {
    register hptr      h, p;
    register int       val;
    register TimeType  edgeT, endT;

    endT = edgeT = min( tims.end, tims.last );
    *edgeH = NULL;
    if( IsVector( t ) )
      {
    register int  i;

    for( i = t->n.vec->nbits - 1; i >= 0; i-- )
      {
        p = h = t->cache[i].wind;
        while( h->time <= tm )
          {
        p = h;
        NEXTH( h, h );
          }
        val = p->val;
        while( h->time <= endT )
          {
        if( val != h->val )
          {
            if( h->time < edgeT )
            edgeT = h->time;
            break;
          }
        NEXTH( h, h );
          }
      }
      }
    else
      {
    p = h = t->cache[0].wind;
    while( h->time <= tm )
      {
        p = h;
        NEXTH( h, h );
      }
    val = p->val;
    while( h->time <= endT )
      {
        if( val != h->val )
          {
        edgeT = h->time;
        *edgeH = h;
        break;
          }
        NEXTH( h, h );
      }
      }
    return( edgeT );
  }


private void WaitForRelease()
  {
    XEvent  e;

    GrabMouse( window, ButtonPressMask | ButtonReleaseMask, None );

    do
    XNextEvent( display, &e );
    while( e.type != ButtonRelease );

    XUngrabPointer( display, CurrentTime );
  }


private    Trptr       t1;
private Coord       x1;
private TimeType    time1;
private void        SetEdge2();


private void Terminate( cancel )
  int  cancel;
  {
    if( cancel )
    PRINT( "(canceled: click on a trace)" );
    SendEventTo( NULL );
    XDefineCursor( display, window, cursors.deflt );
    RestoreScroll();
  }


private void SetEdge1( ev )
  XButtonEvent  *ev;
  {
    TimeType  tm;
    hptr      h;

    if( ev == NULL )
      {
    Terminate( FALSE );
    return;
      }

    if( ev->type != ButtonPress )
    return;

    t1 = GetYTrace( ev->y );
    tm = XToTime( ev->x );
    if( t1 == NULL or tm < 0 )
      {
    Terminate( TRUE );
    return;
      }
    time1 = FindPreviousEdge( t1, tm, &h );
    x1 = TimeToX( time1 );
    PRINTF( "%.1f", d2ns( time1 ) );
    if( h != NULL )
    PRINTF( " [%.1f, %.1f]", d2ns( h->t.r.delay ), d2ns( h->t.r.rtime ) );

    FillAREA( window, x1 - 1, t1->top, 3, t1->bot - t1->top + 1, gcs.hilite );
    WaitForRelease();
    FillAREA( window, x1 - 1, t1->top, 3, t1->bot - t1->top + 1, gcs.unhilite);

    PRINT( " | t2 = " );
    XDefineCursor( display, window, cursors.right );
    SendEventTo( SetEdge2 );
  }


private void SetEdge2( ev )
  XKeyEvent  *ev;
  {
    TimeType  time2, diff;
    Trptr     t2;
    Coord     x2, y1, y2;
    hptr      h;

    if( ev == NULL )
      {
    Terminate( FALSE );
    return;
      }

    if( ev->type != ButtonPress )
    return;

    t2 = GetYTrace( ev->y );
    time2 = XToTime( ev->x );
    if( t2 == NULL or time2 < 0 )
      {
    Terminate( TRUE );
    return;
      }
    time2 = FindNextEdge( t2, time2, &h );
    x2 = TimeToX( time2 );

    if( time2 < time1 )
    diff = time1 - time2;
    else
    diff = time2 - time1;

    PRINTF( "%.1f", d2ns( time2 ) );
    if( h != NULL )
    PRINTF( " [%.1f, %.1f]", d2ns( h->t.r.delay ), d2ns( h->t.r.rtime ) );
    PRINTF( " | diff = %.1f", d2ns( diff ) );

    y1 = (t1->top + t1->bot) / 2;
    y2 = (t2->top + t2->bot) / 2;
    XDrawLine( display, window, gcs.hilite, x1, y1, x2, y2 );
    WaitForRelease();
    XDrawLine( display, window, gcs.unhilite, x1, y1, x2, y2 );

    Terminate( FALSE );
  }


public void DeltaT( s )
  char *s;            /* menu string => ignore it */
  {
    PRINT( "\nt1 = " );
    SendEventTo( SetEdge1 );
    XDefineCursor( display, window, cursors.left );
    DisableScroll();
  }